﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using ShareContent;

namespace AncientEmpires_025_132
{
    public class Character : VisibleGameEntity
    {
        #region Thuộc tính của nhân vật.
        // Tên nhân vật.
        protected CharacterName _name;
        public CharacterName Name
        {
            get { return _name; }
            set { _name = value; }
        }

        // Máu
        protected int _healthPoints;
        public int HealthPoints
        {
            get { return _healthPoints; }
            set { _healthPoints = value; }
        }

        //Cấp độ
        protected int _level;
        public int Level
        {
            get { return _level; }
            set { _level = value; }
        }

        //Sức mạnh (tấn công).
        protected int _minDamage;
        public int MinDamage
        {
            get { return _minDamage; }
            set { _minDamage = value; }
        }

        protected int _maxDamage;
        public int MaxDamage
        {
            get { return _maxDamage; }
            set { _maxDamage = value; }
        }

        //Phòng thủ
        protected int _defense;
        public int Defense
        {
            get { return _defense; }
            set { _defense = value; }
        }

        //Quảng đường tối đa có thể di chuyển được.
        protected int _maxDistance;
        public int MaxDistance
        {
            get { return _maxDistance; }
            set { _maxDistance = value; }
        }

        protected NationName _myNationName;
        public NationName MyNationName
        {
            get { return _myNationName; }
            set { _myNationName = value;
                    switch (_myNationName)
                    {
                        case NationName.None:
                            myIndexNation = 0;
                            break;
                        case NationName.Red:
                            myIndexNation = 1;
                            break;
                        case NationName.Green:
                            myIndexNation = 2;
                            break;
                        case NationName.Blue:
                            myIndexNation = 3;
                            break;
                        case NationName.Black:
                            myIndexNation = 4;
                            break;
                    }
                }
        }

        protected int myIndexNation = 0;
        public int MyIndexNation
        {
            get { return myIndexNation; }
            set { myIndexNation = value; }
        }
        
        private Vector2 _positionInMatrix;
        public Vector2 PositionInMatrix
        {
            get { return _positionInMatrix; }
            set { _positionInMatrix = value; }
        }

        private Texture2D _textureAvatar;
        public Texture2D TextureAvatar
        {
            get { return _textureAvatar; }
            set { _textureAvatar = value; }
        }

        private CharacterSkill mySkill;
        public CharacterSkill MySkill
        {
            get { return mySkill; }
            set { mySkill = value; }
        }

        private int countDrawSkill;
        public int CountDrawSkill
        {
            get { return countDrawSkill; }
            set { countDrawSkill = value; }
        }

        private bool isStartSkill;
        public bool IsStartSkill
        {
            get { return isStartSkill; }
            set { isStartSkill = value; }
        }

        private bool _isEndTurn;
        public bool IsEndTurn
        {
            get { return _isEndTurn; }
            set { _isEndTurn = value; }
        }
        private bool _isDead;

        public bool IsDead
        {
            get { return _isDead; }
            set { _isDead = value; }
        }
        #endregion
        
        #region Các sự kiện của nhân vật phát sinh ra.
        // Sự kiện nhân vật được chọn.
        public delegate void EventHandleSelected(Character character);
        public event EventHandleSelected EventSelected;

        // Sự kiện nhân vật được chọn.
        public delegate void EventHandleHover(bool isHover);
        public event EventHandleHover EventHover;

        // Sự kiện nhân vật được bỏ chọn.
        public delegate void EventHandleUnSelected();
        public event EventHandleUnSelected EventUnSelected;
        // Sự kiện nhân vật bắt đầu di chuyển.
        public delegate void EventHandleStartMoving(Character character);
        public event EventHandleStartMoving EventStartMoving;

        // Sự kiện nhân vật kết thúc 1 lần di chuyển.
        public delegate void EventHandlEndMoving(Character character);
        public event EventHandlEndMoving EventEndMoving;

        // Sự kiện nhân vật kết thúc đánh.
        public delegate void EventHandleEndHurt();
        public event EventHandleEndHurt EventEndHurt;

        // Sự kiện khi nhân vật chết.
        public delegate void EventHandleDead(Character character);
        public event EventHandleDead EventDead;
        
        #endregion

        #region Các properties kiểm tra trạng thái của nhân vật 
        
        private bool _isSelected;
        public bool IsSelected
        {
            get { return _isSelected; }
            set { _isSelected = value; }
        }

        private int _numberOfClick = 0;
        public int NumberOfClick
        {
            get { return _numberOfClick; }
            set { _numberOfClick = value; }
        }
        // Kiểm tra nhân vật đang di chuyển.
        private bool _isMoving = false;
        public bool IsMoving
        {
            get { return _isMoving; }
            set { _isMoving = value; }
        }

        // Trạng thái của nhân vật trong 1 lượt đi của game ( đã đi or chưa đi).
        private bool _isMoved;
        public bool IsMoved
        {
            get { return _isMoved; }
            set { _isMoved = value; }
        }
        
        // Trạng thái right mouse của chuột ở lần trước đó.
        private ButtonState _preRightMouseStateCharacter;
        public ButtonState PreRightMouseStateCharacter
        {
            get { return _preRightMouseStateCharacter; }
            set { _preRightMouseStateCharacter = value; }
        }

        // Trạng thái left mouse của chuột ở lần trước đó
        
        #endregion

        #region Các properties liên quan đến di chuyển của nhân vật
        //Ma trận các cell trong map.
        private Cell[,] _cells;
        public Cell[,] Cells
        {
            get { return _cells; }
            set { _cells = value; }
        }

        //Độ dài mà nhân vật di chuyển trong 1 cell.
        private int _countMoveInCell;
        public int CountMoveInCell
        {
            get { return _countMoveInCell; }
            set { _countMoveInCell = value; }
        }

        //Danh sách các cell trong 1 lần di chuyển của nhân vật.
        private List<Vector2> _listMoving;
        public List<Vector2> ListMoving
        {
            get { return _listMoving; }
            set { _listMoving = value;
                if (_listMoving.Count >= 2)
                    IsMoving = true;
                else IsMoving = false;
                }
        }

        #endregion

        #region Các properties liên quan đến hướng di chuyển
        /// <summary>
        /// Dùng để fix lại vị trí của nhân vật khi draw.
        /// 
        /// </summary>
        
        // Timer bắt sự kiện thay đổi hướng di chuyển để thay đổi Sprite.
        private System.Windows.Forms.Timer _timerHuongDiChuyen;
        public System.Windows.Forms.Timer TimerHuongDiChuyen
        {
            get { return _timerHuongDiChuyen; }
            set { _timerHuongDiChuyen = value; }
        }
        // Hướng chuyển di chuyển của nhân vật.
        private HuongDiChuyen _huongDiChuyenCharacter;
        public HuongDiChuyen HuongDiChuyenCharacter
        {
            get { return _huongDiChuyenCharacter; }
            set { _huongDiChuyenCharacter = value; }
        }

        #endregion


        // Lấy ngẫu nhiên sức mạnh của mỗi lượt đánh
        public int GetRandomDamage()
        {
            Random rd = new Random();
            int damage = rd.Next(MinDamage, MaxDamage);
            if (HealthPoints >= 70)
                return damage;
            if(HealthPoints >= 50)
                return (int)(damage *0.9f);
            if (HealthPoints >= 30)
                return (int)(damage * 0.65f);
            if (HealthPoints >= 10)
                return (int)(damage * 0.7f);
            return (int)(damage * 0.4f);
        }

        // Load content nhân vật từ file xml
        public void LoadContentTexture(ContentManager content, List<TexturesCharacter> listTextureSprite, List<string> listTextureSkill, List<string> listEffectSound, Vector2 position, Vector2 topleft)
        {
            try
            {
                for (int j = 0; j < listTextureSprite.Count; j++)
                {
                    Texture2D[] texture = new Texture2D[listTextureSprite[j].strListTexture.Count];
                    for (int i = 0; i < listTextureSprite[j].strListTexture.Count; i++)
                    {
                        texture[i] = content.Load<Texture2D>(listTextureSprite[j].strListTexture[i]);
                    }
                    Sprite2D tempsprite = new Sprite2D(texture, position, topleft);
                    ListSprites.Add(tempsprite);
                }


                IsStartSkill = false;
                mySkill = new CharacterSkill(content, listTextureSkill.ToArray(), new Vector2(), new Vector2(), new Vector2());
                mySkill.SetViewPort(MapWithCell.CELL_WIDTH, MapWithCell.CELL_HEIGHT);
                IsEndTurn = false;
                mySound = new Sound(content, null, listEffectSound);
                IsDead = false;

            }
            catch (Exception ex)
            {
 
            }
        }
        public void NewCharacter(ContentManager content, ref Vector2 position, ref Vector2 topleft, NationName nationname, string NationName)
        {
            HealthPoints = 100;
            MyNationName = nationname;
            TimerHuongDiChuyen = new System.Windows.Forms.Timer();
            TimerHuongDiChuyen.Interval = 100;
            TimerHuongDiChuyen.Enabled = true;
            TimerHuongDiChuyen.Tick += new EventHandler(TimerHuongDiChuyen_Tick);
            HuongDiChuyenCharacter = HuongDiChuyen.TrenXuongDuoi;
            PreMouseState = ButtonState.Released;
            PreRightMouseStateCharacter = ButtonState.Released;

            ListMoving = new List<Vector2>();
            ListSprites = new List<Sprite2D>();
            foreach (ListSpritesCharacter list in StringTextureCharacter.listCharacter.listCharacters)
            {
                if (list.NameCharacter.ToUpper() == NationName.ToUpper())
                {
                    Defense = list.Defense;
                    MinDamage = list.MinDamage;
                    MaxDamage = list.MaxDamage;
                    MaxDistance = list.MaxDistance;
                    this.TextureAvatar = content.Load<Texture2D>(list.StrTextureAvatar);
                    List<string> liststr = new List<string>();
                    liststr.Add(list.runSoundXMLString);
                    liststr.Add(list.hurtSoundXMLString);
                    liststr.Add(list.ishurtedSoundXMLString);
                    LoadContentTexture(content, list.listSprites, list.listSkill, liststr, position, topleft);
                    //
                    //SetColorAfterNation(list.listColorIsChanged, MyNationName);
                    break;
                }
            }
            
        }
        // Timer kiểm tra thay đổi hướng của nhân vật
        public void TimerHuongDiChuyen_Tick(object sender, EventArgs e)
        {
            switch (HuongDiChuyenCharacter)
            {
                case HuongDiChuyen.DuoiLenTren:
                    ISprite = 0;
                    break;
                case HuongDiChuyen.TrenXuongDuoi:
                    ISprite = 1;
                    break;
                case HuongDiChuyen.PhaiQuaTrai:
                    ISprite = 2;
                    break;
                case HuongDiChuyen.TraiQuaPhai:
                    ISprite = 3;
                    break;
            }


            if (IsMoving)
            {
                ListSprites[ISprite].ITexture = (ListSprites[ISprite].ITexture + 1) % ListSprites[ISprite].NTextures;
            }
            else
            {
                ListSprites[ISprite].ITexture = 0;
            }
            
        }

        

        

        // Nhân vật di chuyển từng cell trong ListMoving
        public void MoveCellByCell()
        {
            Vector2 topLeft = -ListSprites[ISprite].TopLeft;
            if (ListMoving.Count >= 2)
            {
                MySound.IEffect = 0;
                MySound.PlayEffect(Volume.MyVolume);
                IsMoving = true;
                if (ListMoving[0].X == ListMoving[1].X && ListMoving[0].Y < ListMoving[1].Y)
                {
                    //HuongDiChuyenCharacter = HuongDiChuyen.TrenXuongDuoi;
                    HuongDiChuyenCharacter = HuongDiChuyen.TraiQuaPhai;
                    topLeft.X += UnitGameEntity.UnitMoveOfCharacterNormal;
                }
                if (ListMoving[0].X == ListMoving[1].X && ListMoving[0].Y > ListMoving[1].Y)
                {
                    //HuongDiChuyenCharacter = HuongDiChuyen.DuoiLenTren;
                    HuongDiChuyenCharacter = HuongDiChuyen.PhaiQuaTrai;
                    topLeft.X -= UnitGameEntity.UnitMoveOfCharacterNormal;
                }
                if (ListMoving[0].X < ListMoving[1].X && ListMoving[0].Y == ListMoving[1].Y)
                {
                    //HuongDiChuyenCharacter = HuongDiChuyen.TraiQuaPhai;
                    HuongDiChuyenCharacter = HuongDiChuyen.TrenXuongDuoi;
                    topLeft.Y += UnitGameEntity.UnitMoveOfCharacterNormal;
                }
                if (ListMoving[0].X > _listMoving[1].X && ListMoving[0].Y == ListMoving[1].Y)
                {
                    //HuongDiChuyenCharacter = HuongDiChuyen.PhaiQuaTrai;
                    HuongDiChuyenCharacter = HuongDiChuyen.DuoiLenTren;
                    topLeft.Y -= UnitGameEntity.UnitMoveOfCharacterNormal;
                }
                CountMoveInCell += UnitGameEntity.UnitMoveOfCharacterNormal;
                if (HuongDiChuyenCharacter == HuongDiChuyen.TrenXuongDuoi || HuongDiChuyenCharacter == HuongDiChuyen.DuoiLenTren)
                {
                    if (CountMoveInCell >= MapWithCell.CELL_HEIGHT)
                    {
                        CountMoveInCell = 0;
                        ListMoving.RemoveAt(0);
                    }
                }
                if (HuongDiChuyenCharacter == HuongDiChuyen.TraiQuaPhai || HuongDiChuyenCharacter == HuongDiChuyen.PhaiQuaTrai)
                {
                    if (CountMoveInCell >= MapWithCell.CELL_HEIGHT)
                    {
                        CountMoveInCell = 0;
                        ListMoving.RemoveAt(0);
                    }
                }
                for (int i = 0; i < ListSprites.Count; i++)
                {
                    ListSprites[i].TopLeft = -topLeft;
                }
            }
            else
            {
                IsMoving = false;
                Cells[(int)PositionInMatrix.X, (int)PositionInMatrix.Y].IsUsed = IndexNation.Available;
                PositionInMatrix = new Vector2(-((int)(ListSprites[ISprite].TopLeft.Y - Cells[0, 0].ListSprites[Cells[0, 0].ISprite].TopLeft.Y) / MapWithCell.CELL_HEIGHT),
                                                -((int)(ListSprites[ISprite].TopLeft.X - Cells[0, 0].ListSprites[Cells[0, 0].ISprite].TopLeft.X) / MapWithCell.CELL_WIDTH));
                Cells[(int)PositionInMatrix.X, (int)PositionInMatrix.Y].IsUsed = this.myIndexNation;
                EventEndMoving(this);
            }
        }

        public override void UpdateMouseState()
        {
            if (IsDead)
            {
                EventDead(this);
            }
            MouseState ms = Mouse.GetState();
            #region Bắt sự kiện chuột chọn nhân vật và di chuyển nhân vật.
            if (this.MyNationName == CurrentCircle.NationCurrent && !IsMoved && !IsMoving && !IsEndTurn)
            {
                if (ms.RightButton == ButtonState.Pressed)
                {
                    if (IsSelected)
                    {
                        NumberOfClick = 0;
                        IsSelected = false;
                        EventUnSelected();
                    }
                }
                else
                {
                }
                if (ms.LeftButton == ButtonState.Pressed)
                {
                    if ((NumberOfClick == 0 && CheckClickSprite(new Vector2(ms.X, ms.Y))) || NumberOfClick > 0)
                    {
                        if (PreMouseState == ButtonState.Released)
                        {
                            PreMouseState = ButtonState.Pressed;
                            NumberOfClick = (NumberOfClick + 1) % 3;
                        }
                    }
                }
                else
                {
                    if (CheckHoverSpirte(new Vector2(ms.X, ms.Y)))
                    {
                        IsHover = true;
                    }
                    else
                    {
                        IsHover = false;
                    }
                    if (PreMouseState == ButtonState.Pressed)
                    {
                        PreMouseState = ButtonState.Released;
                    }
                }

                switch (NumberOfClick)
                {
                    case 1: // Chon nhan vat.
                        {
                            if (!IsSelected && PreMouseState == ButtonState.Released)
                            {
                                IsSelected = true;
                                EventSelected(this);
                            }
                            break;
                        }

                    case 2: // Đã chọn nhân vật và release left button để nhân vật di chuyển.
                        {
                            //Di chuyển 1 nhân vật.
                            if (IsSelected)
                            {
                                IsSelected = false;
                                EventStartMoving(this);
                                NumberOfClick = 0;
                            }
                            break;
                        }
                }
            }
            else
            {
                IsHover = false;
            }
            #endregion
        }

        public override bool CheckClickSprite(Vector2 ms)
        {
            if (ms.X >= this.ListSprites[ISprite].Position.X + this.ViewPort.X
               && ms.X <= this.ListSprites[ISprite].Position.X + this.ListSprites[ISprite].Size.X
               && ms.Y >= this.ListSprites[ISprite].Position.Y - this.ViewPort.Y
               && ms.Y <= this.ListSprites[ISprite].Position.Y + this.ListSprites[ISprite].Size.Y)
            {
                return true;
            }
            return false;
        }
        public override bool CheckHoverSpirte(Vector2 ms)
        {
            if (ms.X >= this.ListSprites[ISprite].Position.X + this.ViewPort.X
               && ms.X <= this.ListSprites[ISprite].Position.X + this.ListSprites[ISprite].Size.X
               && ms.Y >= this.ListSprites[ISprite].Position.Y - this.ViewPort.Y
               && ms.Y <= this.ListSprites[ISprite].Position.Y + this.ListSprites[ISprite].Size.Y)
            {
                return true;
            }
            return false;
        }
        public override void Update(GameTime gametime)
        {
            if (HealthPoints <= 0)
            {
                EventDead(this);
            }
            UpdateMouseState();
            if (IsMoving)
            {
                MoveCellByCell();
            }
            else
            {
                Cells[(int)PositionInMatrix.X, (int)PositionInMatrix.Y].IsUsed = IndexNation.Available;
                PositionInMatrix = new Vector2(-((int)(ListSprites[ISprite].TopLeft.Y - Cells[0, 0].ListSprites[Cells[0, 0].ISprite].TopLeft.Y) / MapWithCell.CELL_HEIGHT),
                                                -((int)(ListSprites[ISprite].TopLeft.X - Cells[0, 0].ListSprites[Cells[0, 0].ISprite].TopLeft.X) / MapWithCell.CELL_WIDTH));
                Cells[(int)PositionInMatrix.X, (int)PositionInMatrix.Y].IsUsed = this.myIndexNation;
            }
            for (int i = 0; i < ListSprites.Count; i++)
            {
                ListSprites[i].Position = -ListSprites[i].TopLeft + this.ViewPort;
            }
            MySkill.Update(gametime);
        }

        public override void Draw(GameTime gameTime, SpriteBatch spriteBatch)
        {
            for (int i = 0; i < ListSprites.Count; i++)
            {
                if (i == ISprite)
                {
                    Rectangle rect = new Rectangle();
                    if (ListSprites[i].Size.X == 0 && ListSprites[i].Size.Y == 0)
                    {
                        ListSprites[i].Size = new Vector2(ListSprites[i].Textures[ListSprites[i].ITexture].Width, ListSprites[i].Textures[ListSprites[i].ITexture].Height);
                    }
                    rect = new Rectangle((int)ListSprites[i].Position.X, (int)ListSprites[i].Position.Y, (int)ListSprites[i].Size.X, (int)ListSprites[i].Size.Y);
                    Color color = new Color();
                    if (IsEndTurn)
                    {
                        color = Color.DarkGray;
                    }
                    else color = Color.White;
                    spriteBatch.Draw(ListSprites[i].Textures[ListSprites[i].ITexture], rect, color);
                    DrawHP(gameTime, spriteBatch, new Vector2((int)ListSprites[i].Position.X, (int)ListSprites[i].Position.Y));
                    break;
                }
            }

            if (IsStartSkill)
            {
                CountDrawSkill++;
                if (countDrawSkill == 20)
                {
                    CountDrawSkill = 0;
                    IsStartSkill = false;
                    IsEndTurn = true;
                    EventEndHurt();
                }
                MySkill.Draw(gameTime, spriteBatch);
            }
        }
        public void DrawHP(GameTime gameTime, SpriteBatch spriteBatch, Vector2 pos)
        {
            int width = (int)(MapWithCell.CELL_WIDTH * (float)((float)HealthPoints / 100f));
            if (width < 0) width = 0;
            int height = (int)(MapWithCell.CELL_HEIGHT * 0.12f);
            Texture2D rect = new Texture2D(spriteBatch.GraphicsDevice, width , height);

            Color[] data = new Color[width * height];
            for (int i = 0; i < data.Length; ++i)
            {
                if(this.HealthPoints >= 50)
                    data[i] = Color.Green;
                else
                    data[i] = Color.Red;
            }
            rect.SetData(data);
            spriteBatch.Draw(rect, pos, Color.White);
        }
        /*
        //Change character after nation color
        public void SetColorAfterNation(List<Color> listBeChangeColor)
        {
            for (int i = 0; i < ListSprites.Count; i++)
            {
                for (int j = 0; j < ListSprites[i].NTextures; j++)
                {
                    Texture2D changeTexture = ListSprites[i].Textures[j];
                    changeTexture = SetTextureColorAfterNation(listBeChangeColor, changeTexture);
                    ListSprites[i].Textures[j] = changeTexture;
                }
            }
        }

        //Change color texture after nation color
        public Texture2D SetTextureColorAfterNation(List<Color> listBeChangeColor, Texture2D changeTexture)
        {
            Texture2D result = null;
            Color[] data;
            data = new Color[changeTexture.Width * changeTexture.Height];
            changeTexture.GetData(data);
            for (int i = 0; i < data.Length; i++)
            {
                for (int j = 0; j < listBeChangeColor.Count; j++)
                {
                    if (data[i] == listBeChangeColor[j])
                    {
                        int b = 0, r = 0, g = 0;
                        switch (MyNationName)
                        { 
                            case NationName.Blue:
                                b = (int)MathHelper.Max(MathHelper.Max(listBeChangeColor[j].R, listBeChangeColor[j].B),listBeChangeColor[j].G);
                                r = (int)MathHelper.Min(MathHelper.Min(listBeChangeColor[j].R, listBeChangeColor[j].B),listBeChangeColor[j].G);
                                if (listBeChangeColor[j].R < b && listBeChangeColor[j].R > r) g=listBeChangeColor[j].R;
                                else if (listBeChangeColor[j].B < b && listBeChangeColor[j].B > r) g = listBeChangeColor[j].B;
                                else if (listBeChangeColor[j].G < b && listBeChangeColor[j].G > r) g = listBeChangeColor[j].G;
                                break;
                            case NationName.Green:
                                g = (int)MathHelper.Max(MathHelper.Max(listBeChangeColor[j].R, listBeChangeColor[j].B),listBeChangeColor[j].G);
                                b = (int)MathHelper.Min(MathHelper.Min(listBeChangeColor[j].R, listBeChangeColor[j].B),listBeChangeColor[j].G);
                                if (listBeChangeColor[j].R < g && listBeChangeColor[j].R > b) r=listBeChangeColor[j].R;
                                else if (listBeChangeColor[j].B < g && listBeChangeColor[j].B > b) r = listBeChangeColor[j].B;
                                else if (listBeChangeColor[j].G < g && listBeChangeColor[j].G > b) r = listBeChangeColor[j].G;
                                break;
                            case NationName.Red:
                                r = (int)MathHelper.Max(MathHelper.Max(listBeChangeColor[j].R, listBeChangeColor[j].B),listBeChangeColor[j].G);
                                b = (int)MathHelper.Min(MathHelper.Min(listBeChangeColor[j].R, listBeChangeColor[j].B),listBeChangeColor[j].G);
                                if (listBeChangeColor[j].R < r && listBeChangeColor[j].R > b) g=listBeChangeColor[j].R;
                                else if (listBeChangeColor[j].B < r && listBeChangeColor[j].B > b) g = listBeChangeColor[j].B;
                                else if (listBeChangeColor[j].G < r && listBeChangeColor[j].G > b) g = listBeChangeColor[j].G;
                                break;
                            case NationName.Black:
                                r = (int)Math.Sqrt(listBeChangeColor[j].R);
                                b = (int)Math.Sqrt(listBeChangeColor[j].B);
                                g = (int)Math.Sqrt(listBeChangeColor[j].G);
                                break;
                        }
                        data[i] = new Color(r, b, g);
                        break;
                    }
                }
            }
            result.SetData(data);
            return result;
        }*/
    }
}
